import asyncio
import uuid
from abc import ABC, abstractmethod
from typing import Any, AsyncGenerator, Callable, Dict, List, Mapping, Sequence, Optional

from autogen_agentchat.base import ChatAgent, TerminationCondition, TaskResult
from autogen_agentchat.messages import BaseAgentEvent, BaseChatMessage, MessageFactory, StructuredMessage, TextMessage, \
    StopMessage, ModelClientStreamingChunkEvent
from autogen_agentchat.teams._group_chat._chat_agent_container import ChatAgentContainer
from autogen_agentchat.teams._group_chat._events import GroupChatTermination, SerializableException, GroupChatStart, \
    GroupChatReset
from autogen_agentchat.teams._group_chat._sequential_routed_agent import SequentialRoutedAgent
from autogen_core import ComponentBase, AgentRuntime, SingleThreadedAgentRuntime, AgentType, TypeSubscription, \
    CancellationToken, AgentId
from autogen_core.models import ChatCompletionClient
from pydantic import BaseModel, ValidationError

from backend.state.states import ButlerTeamState
from backend.teams.bulter_team import ButlerTeam


class BaseGroupChat(ButlerTeam, ABC, ComponentBase[BaseModel]):
    """

    管家基础工作群，由多智能体组成，负责处理复杂任务。
    要实现一个团队管理员，继承：class:`BaseGroupChatManager`

    """

    component_type = "da_guan_yuan"

    def __init__(self,
                 participants: List[ChatAgent],
                 group_chat_manager_name: str,
                 group_chat_manager_class: type[SequentialRoutedAgent],
                 termination_condition: TerminationCondition | None = None,
                 max_turns: int | None = None,
                 runtime: AgentRuntime | None = None,
                 custom_message_types: List[type[BaseAgentEvent | BaseChatMessage]] | None = None,
                 emit_team_events: bool = False,):
        if len(participants) == 0:
            raise ValueError("至少需要一个参与者")
        if len(participants) != len(set(participant.name for participant in participants)):
            raise ValueError("所有参与者的名称必须是唯一的")

        # 初始化字段
        self._participants = participants
        self._base_group_chat_manager_class = group_chat_manager_class
        self._termination_condition = termination_condition
        self._max_turns = max_turns
        self._message_factory = MessageFactory()
        # 注册自定义消息类型
        if custom_message_types is not None:
            for message_type in custom_message_types:
                self._message_factory.register(message_type)

        # 参与者
        for participant in participants:
            for message_type in participant.produced_message_types:
                try:
                    is_required = self._message_factory.is_registered(message_type)
                    if issubclass(message_type,StructuredMessage) and not is_required:
                        self._message_factory.register(message_type)
                except TypeError:
                    # 如果消息类型已注册，则忽略
                    pass
        # 团队 ID 是一个 UUID，用于在代理运行时标识团队及其参与者。它用于为每个参与者创建唯一的主题类型。
        # 目前，团队 ID 绑定到群聊类的对象实例。因此，如果创建两个群聊实例，将存在两个具有不同 ID 的团队。
        self._team_id = str(uuid.uuid4())

        # 群聊团队的常量。
        # 这些名称用于标识团队中的代理。
        # 不同团队之间的名称可能不唯一。
        self._group_chat_manager_name = group_chat_manager_name
        self._participant_names: List[str] = [participant.name for participant in participants]
        self._participant_descriptions: List[str] = [participant.description for participant in participants]
        # 群聊主题类型用于所有参与者与群聊管理器之间的广播通信。
        self._group_topic_type = f"group_topic_{self._team_id}"
        # 群聊管理器的主题类型用于群聊管理器与其他参与者之间的广播通信。
        self._group_chat_manager_topic_type = f"{self._group_chat_manager_name}_{self._team_id}"
        # 参与者主题类型用于与每个参与者进行直接通信。
        self._participant_topic_types: List[str] = [
            f"{participant.name}_{self._team_id}" for participant in participants
        ]
        # 输出主题类型用于从群聊中发送流式消息。
        # 群聊管理器会将消息转发到输出消息队列。
        self._output_topic_type = f"output_{self._team_id}"
        # 输出消息队列用于存储从群聊中接收到的消息。
        self._output_message_queue: asyncio.Queue[BaseAgentEvent | BaseChatMessage | GroupChatTermination] = (
            asyncio.Queue()
        )
        # 创建一个团队运行时
        if runtime is not None:
            self._runtime = runtime
            self._embedded_runtime = False
        else:
            # 为工作群组创建一个内嵌的单线程运行时.（运行时，负责发送事件）
            self._runtime = SingleThreadedAgentRuntime(ignore_unhandled_exceptions=False)
            self._embedded_runtime = True

        # 定义状态标识
        self._initialized = False
        self._is_running = False
        self._is_started = False
        self._emit_team_events = emit_team_events
        self._shutdown_task = Optional[asyncio.Task[None]] = None


    @abstractmethod
    def _create_group_chat_manager_factory(
        self,
        name: str,
        group_topic_type: str,
        output_topic_type: str,
        participant_topic_types: List[str],
        participant_names: List[str],
        participant_descriptions: List[str],
        output_message_queue: asyncio.Queue[BaseAgentEvent | BaseChatMessage | GroupChatTermination],
        termination_condition: TerminationCondition | None,
        max_turns: int | None,
        message_factory: MessageFactory,
    ) -> Callable[[], SequentialRoutedAgent]: ...

    def _create_participant_factory(
        self,
        parent_topic_type: str,
        output_topic_type: str,
        agent: ChatAgent,
        message_factory: MessageFactory,
    ) -> Callable[[], ChatAgentContainer]:
        def _factory() -> ChatAgentContainer:
            container = ChatAgentContainer(parent_topic_type, output_topic_type, agent, message_factory)
            return container

        return _factory


    async def _init(self, runtime: AgentRuntime) -> None:
        # 群组聊天管理器的常量。
        group_chat_manager_agent_type = AgentType(self._group_chat_manager_topic_type)

        # 注册参与者。
        # 使用参与者主题类型作为代理类型。
        for participant, agent_type in zip(self._participants, self._participant_topic_types, strict=True):
            # 注册参与者工厂。
            await ChatAgentContainer.register(
                runtime,
                type=agent_type,
                factory=self._create_participant_factory(
                    self._group_topic_type, self._output_topic_type, participant, self._message_factory
                ),
            )

        # 为参与者添加订阅。
        # 参与者应能够从其自身的主题接收消息。
        await runtime.add_subscription(TypeSubscription(topic_type=agent_type, agent_type=agent_type))
        # 参与者应能够从群组主题接收消息。
        await runtime.add_subscription(TypeSubscription(topic_type=self._group_topic_type, agent_type=agent_type))
        # 注册群组聊天管理器。
        await self._base_group_chat_manager_class.register(
            runtime,
            type=group_chat_manager_agent_type.type,
            factory=self._create_group_chat_manager_factory(
                name=self._group_chat_manager_name,
                group_topic_type=self._group_topic_type,
                output_topic_type=self._output_topic_type,
                participant_names=self._participant_names,
                participant_topic_types=self._participant_topic_types,
                participant_descriptions=self._participant_descriptions,
                output_message_queue=self._output_message_queue,
                termination_condition=self._termination_condition,
                max_turns=self._max_turns,
                message_factory=self._message_factory,
            ),
        )

        # 为群组聊天管理器添加订阅。
        # 群组聊天管理器应能够从其自身的主题接收消息。
        await runtime.add_subscription(
            TypeSubscription(
                topic_type=self._group_chat_manager_topic_type, agent_type=group_chat_manager_agent_type.type
            )
        )
        # 群组聊天管理器应能够从群组主题接收消息。
        await runtime.add_subscription(
            TypeSubscription(topic_type=self._group_topic_type, agent_type=group_chat_manager_agent_type.type)
        )
        # 群组聊天管理器将把输出主题的消息转发到输出消息队列。
        await runtime.add_subscription(
            TypeSubscription(topic_type=self._output_topic_type, agent_type=group_chat_manager_agent_type.type)
        )

        self._initialized = True

    async def run(
        self,
        *,
        task: str | BaseChatMessage | Sequence[BaseChatMessage] | None = None,
        cancellation_token: CancellationToken | None = None,
    ) -> TaskResult:
        """
        运行团队并返回结果。基础实现使用 :meth:`run_stream` 运行团队，然后返回最终结果。
        一旦团队停止，终止条件将被重置。
        参数：
            task (str | BaseChatMessage | Sequence[BaseChatMessage] | None)：用于运行团队的任务。可以是字符串、单个 :class:`BaseChatMessage` 或 :class:`BaseChatMessage` 列表。
            cancellation_token (CancellationToken | None)：用于立即终止任务的取消令牌。
                设置取消令牌可能会使团队处于不一致状态，
                并且可能不会重置终止条件。
                若要正常停止团队，请改用 :class:`~autogen_agentchat.conditions.ExternalTermination`。

        返回：
            result：任务结果，类型为 :class:`~autogen_agentchat.base.TaskResult`。结果包含团队生成的消息和停止原因。
        """
        result: Optional[TaskResult] = None
        async for message in self.run_stream(
                task=task,
                cancellation_token=cancellation_token,
        ):
            if isinstance(message, TaskResult):
                result = message
        if result is not None:
            return result
        raise AssertionError("The stream should have returned the final result.")

    async def run_stream(
            self,
            *,
            task: str | BaseChatMessage | Sequence[BaseChatMessage] | None = None,
            cancellation_token: CancellationToken | None = None,
    ) -> AsyncGenerator[BaseAgentEvent | BaseChatMessage | TaskResult, None]:
        """ 运行团队并生成消息流，流中的最后一项为类型为 :class:~autogen_agentchat.base.TaskResult 的最终结果。一旦团队停止，终止条件将被重置。
        .. note::
        如果某个代理生成了 :class:~autogen_agentchat.messages.ModelClientStreamingChunkEvent，该消息将在流中产生，但不会包含在 :attr:~autogen_agentchat.base.TaskResult.messages 中。
        参数：
        task (str | BaseChatMessage | Sequence [BaseChatMessage] | None)：用于运行团队的任务。可以是字符串、单个 :class:BaseChatMessage 或 :class:BaseChatMessage 列表。
        cancellation_token (CancellationToken | None)：用于立即终止任务的取消令牌。
        设置取消令牌可能会使团队处于不一致状态，
        并且可能不会重置终止条件。
        若要正常停止团队，请改用 :class:~autogen_agentchat.conditions.ExternalTermination。
        返回：
        stream：一个 :class:~collections.abc.AsyncGenerator，它会生成 :class:~autogen_agentchat.messages.BaseAgentEvent、:class:~autogen_agentchat.messages.BaseChatMessage，并将最终结果 :class:~autogen_agentchat.base.TaskResult 作为流中的最后一项。"""
        # 创建消息列表用于存储任务生成的消息。
        messages: List[BaseChatMessage] | None = None
        if task is None:
            pass
        elif isinstance(task, str):
            messages = [TextMessage(content=task, source="user")]
        elif isinstance(task, BaseChatMessage):
            messages = [task]
        elif isinstance(task, list):
            if not task:
                raise ValueError("任务是列表时不能为空。")
            messages = []
            for msg in task:
                if not isinstance(msg, BaseChatMessage):
                    raise ValueError("任务列表所有消息必须是有效的BaseChatMessage类型")
                messages.append(msg)
        else:
            raise ValueError("任务类型只能是字符串、BaseChatMessage或BaseChatMessage列表。")

        # 检查消息类型确保注册到消息工厂
        if messages is not None:
            for message in messages:
                if not self._message_factory.is_registered(message.__class__):
                    raise ValueError(f"消息类型 {message.__class__.__name__} 未注册到消息工厂。"
                                     "在创建团队时，请确保将所有消息类型注册到消息工厂。"
                                     )
        if self._is_running:
            raise RuntimeError("团队正在运行中。必须先停止团队才能重新运行。")
        self._is_running = True

        if self._embedded_runtime:
            # 启动运行时
            assert isinstance(self._runtime, SingleThreadedAgentRuntime)
            self._runtime.start()

        if not self._initialized:
            await self._init(self._runtime)

        # 保存任务
        shutdown_task: Optional[asyncio.Task[None]]  = None

        if self._emit_team_events:
            # 启动团队事件流
            async def stop_runtime() -> None:
                assert isinstance(self._runtime, SingleThreadedAgentRuntime)
                try:
                    # 这里会传播任何异常。
                    await self._runtime.stop_when_idle()
                    # 设置一个停止消息，指示群聊已停止，但不是由于异常导致的。
                    await self._output_message_queue.put(
                        GroupChatTermination(
                            message=StopMessage(
                                content="The group chat is stopped.", source=self._group_chat_manager_name
                            )
                        )
                    )
                except Exception as e:
                    # 停止消息消费并结束流。
                    # 注意：我们还需要在此处放置一个GroupChatTermination事件，因为当运行时
                    # 发生异常时，群聊管理器可能无法将GroupChatTermination事件放入队列中。
                    # 如果群聊管理器能够处理异常并将事件放入队列，这可能不是必需的。
                    await self._output_message_queue.put(
                        GroupChatTermination(
                            message=StopMessage(
                                content="An exception occurred in the runtime.", source=self._group_chat_manager_name
                            ),
                            error=SerializableException.from_exception(e),
                        )
                    )

            # 创建一个后台任务，用于在运行时停止时发送停止消息。
            # 停止任务或者运行时异常时，都会发送停止消息。
            shutdown_task = asyncio.create_task(stop_runtime())


        try:
            # 运行团队并发送一个开始消息到群管理员.
            # 群管理器通过把消息转发给你参与者和群聊管理器来启动群聊.
            await self._runtime.send_message(
                GroupChatStart(messages=messages),
                recipient=AgentId(type=self._group_chat_manager_topic_type, key=self._team_id),
                cancellation_token=cancellation_token,
            )

            # 按顺序收集输出消息。
            output_messages: List[BaseAgentEvent | BaseChatMessage] = []
            stop_reason: str | None = None
            # 迭代输出消息队列，直到队列为空。
            while True:
                message_future = asyncio.ensure_future(self._output_message_queue.get())
                if cancellation_token is not None:
                    cancellation_token.link_future(message_future)
                # 等待下一个消息，如果任务被取消，将抛出异常。
                message = await message_future
                if isinstance(message, GroupChatTermination):
                    # 检查是否有错误，如果有错误，则抛出异常。
                    # 这将停止团队并传播错误。
                    if message.error is not None:
                        raise RuntimeError(str(message.error))
                    stop_reason = message.message.content
                    break
                yield message
                if isinstance(message, ModelClientStreamingChunkEvent):
                    # 跳过模型客户端流式块事件。
                    continue
                output_messages.append(message)

            # 迭代返回最终结果包含所有输出消息和停止原因。
            yield TaskResult(messages=output_messages, stop_reason=stop_reason)

        finally:
            try:
                if shutdown_task is not None:
                    # 等待后台任务完成。这将传播任何异常。
                    await shutdown_task
            finally:
                # 清除输出消息队列。
                while not self._output_message_queue.empty():
                    self._output_message_queue.get_nowait()

                # 标注团队不再运行。
                self._is_running = False


    async def dispatch(self, message: BaseChatMessage) -> None:
        """
        调度一个消息到团队。
        这个方法将消息发送到群聊管理器，由群聊管理器将消息转发给所有的参与者。
        参数：
            message (BaseChatMessage)：要调度的消息。
        """
        if not self._initialized:
            raise RuntimeError("团队未初始化。只有运行中的团队才能调度消息。")
        await self._runtime.send_message(
            GroupChatStart(messages=[message]),
            recipient=AgentId(type=self._group_chat_manager_topic_type, key=self._team_id),
        )


    async def reset(self) -> None:
        """
        重置团队状态和成员状体为初始状态.
        只有但团队停止后才能重置。
        异常：
            RuntimeError：如果团队正在运行或者未初始化，则抛出此异常。
        """
        if not self._initialized:
            await self._init(self._runtime)
        if self._is_running:
            raise RuntimeError("团队正在运行中。必须先停止团队才能暂停。")
        self._is_running = True
        # 如果使用内嵌运行时，则需要启动运行时。
        if self._embedded_runtime:
            assert isinstance(self._runtime, SingleThreadedAgentRuntime)
            self._runtime.start()

        try:
            # 发送重置消息到每个群成员
            for participant_topic_type in self._participant_topic_types:
                await self._runtime.send_message(
                    message=GroupChatReset(),
                    recipient=AgentId(type=participant_topic_type, key=self._team_id),
                )
            # 发送重置消息到群聊管理器
            await self._runtime.send_message(
                message=GroupChatReset(),
                recipient=AgentId(type=self._group_chat_manager_topic_type, key=self._team_id),
            )
        except Exception as e:
            raise RuntimeError("重置团队状态时出错。") from e
        finally:
            # 标注团队不再运行。
            if self._embedded_runtime:
                # 停止运行时
                assert isinstance(self._runtime, SingleThreadedAgentRuntime)
                await self._runtime.stop_when_idle()

            # 重置消息队列
            while not self._output_message_queue.empty():
                self._output_message_queue.get_nowait()

            # 标注团队不再运行。
            self._is_running = False



    async def pause(self) -> None:
        """暂停团队及其所有参与者。这对于暂停:meth:`autogen_agentchat.base.TaskRunner.run`或
        :meth:`autogen_agentchat.base.TaskRunner.run_stream`方法的并发执行同时保持它们运行状态非常有用。"""

        if not self._initialized:
            raise RuntimeError("团队未初始化。只有运行中的团队才能被暂停")

        # 发送暂停消息到每个群成员
        for participant_topic_type in self._participant_topic_types:
            await self._runtime.send_message(
                message=GroupChatReset(),
                recipient=AgentId(type=participant_topic_type, key=self._team_id),
            )

        # 发送暂停消息到群聊管理器
        await self._runtime.send_message(
            message=GroupChatReset(),
            recipient=AgentId(type=self._group_chat_manager_topic_type, key=self._team_id),
        )


    async def resume(self) -> None:
        """在调用:meth:`pause`方法暂停后，恢复团队及其所有参与者的运行。"""

        if not self._initialized:
            raise RuntimeError("团队未初始化。只有运行中的团队才能恢复暂停")

        # 发送恢复消息到每个群成员
        for participant_topic_type in self._participant_topic_types:
            await self._runtime.send_message(
                message=GroupChatReset(),
                recipient=AgentId(type=participant_topic_type, key=self._team_id),
            )
        # 发送恢复消息到群聊管理器
        await self._runtime.send_message(
            message=GroupChatReset(),
            recipient=AgentId(type=self._group_chat_manager_topic_type, key=self._team_id),
        )


    async def save_state(self) -> Mapping[str, Any]:
        """
        保存团队的当前状态。
        通过使用每个参与者和群聊管理器的内部代理 ID 调用 :meth:`AgentRuntime.save_state` 方法来保存每个代理的状态。
        返回：
            state (Mapping[str, Any]): 包含每个代理的状态的映射，键为代理 ID，值为代理的状态。
        """
        if not self._initialized:
            await self._init(self._runtime)

        # 通过名字存储每个代理的状态
        # 注意：我们这里不使用代理ID作为键，是希望将代理的状态与他们运行时的身份进行解耦
        # 定义代理状态存储字典
        agent_states :Dict[str,Mapping[str,any]]={}
        # 保存所有
        for name,agent_type in zip(self._participant_names,self._participant_topic_types,strict=True):
            agent_id = AgentId(type=agent_type, key=self._team_id)
            # 使用runtime 保存每个代理的状态
            agent_states[name]=await self._runtime.agent_save_state(agent_id)
        #保存群聊管理器
        agent_id = AgentId(type=self._group_chat_manager_topic_type, key=self._team_id)
        agent_states[self._group_chat_manager_name] = await self._runtime.agent_save_state(agent_id)
        return ButlerTeamState(agent_states=agent_states).model_dump()

    async def load_state(self, state: Mapping[str, Any]) -> None:
        """
        加载团队的状态。
        加载外部状态并覆盖群聊团队的当前状态。
        通过使用每个参与者和群聊管理器的内部代理 ID 调用 :meth:~autogen_core.AgentRuntime.agent_load_state 方法来加载状态。
        参数：
            state (Mapping[str, Any]): 包含每个代理的状态的映射，键为代理 ID，值为代理的状态。
        """
        if not self._initialized:
            await self._init(self._runtime)

        if self._is_running:
            raise RuntimeError("团队正在运行中。必须先停止团队才能加载状态。")
        self._is_running = True
        try:
            team_state = ButlerTeamState.model_validate(state)
            # 加载所有参与者状态
            for name, agent_type in zip(self._participant_names, self._participant_topic_types, strict=True):
                agent_id = AgentId(type=agent_type, key=self._team_id)
                if name not in team_state.agent_states:
                    raise ValueError(f"在保存数据中未找到成员 {name} 的状态数据。")
                await self._runtime.agent_load_state(agent_id, team_state.agent_states[name])
            # 加载群聊管理器状态
            agent_id = AgentId(type=self._group_chat_manager_topic_type, key=self._team_id)
            if self._group_chat_manager_name not in team_state.agent_states:
                raise ValueError(f"在保存数据中未找到成员 {self._group_chat_manager_name} 的状态数据。")
            await self._runtime.agent_load_state(agent_id, team_state.agent_states[self._group_chat_manager_name])

        except ValidationError as e:
            raise ValueError(
                "非法状态格式 "
            ) from e

        finally:
            # 标志状不在运行
            self._is_running = False


    async def start(self) -> None:
        """
        启动团队运行。
        """
        if self._is_running:
            raise RuntimeError("团队正在运行中。必须先停止团队才能重新运行。")
        self._is_running = True

        if self._embedded_runtime:
            # 启动运行时
            assert isinstance(self._runtime, SingleThreadedAgentRuntime)
            self._runtime.start()

        if not self._initialized:
            await self._init(self._runtime)

        # 保存任务
        if self._emit_team_events:
            # 启动团队事件流
            async def stop_runtime() -> None:
                assert isinstance(self._runtime, SingleThreadedAgentRuntime)
                try:
                    # 这里会传播任何异常。
                    await self._runtime.stop_when_idle()
                    # 设置一个停止消息，指示群聊已停止，但不是由于异常导致的。
                    await self._output_message_queue.put(
                        GroupChatTermination(
                            message=StopMessage(
                                content="The group chat is stopped.", source=self._group_chat_manager_name
                            )
                        )
                    )
                except Exception as e:
                    # 停止消息消费并结束流。
                    # 注意：我们还需要在此处放置一个GroupChatTermination事件，因为当运行时
                    # 发生异常时，群聊管理器可能无法将GroupChatTermination事件放入队列中。
                    # 如果群聊管理器能够处理异常并将事件放入队列，这可能不是必需的。
                    await self._output_message_queue.put(
                        GroupChatTermination(
                            message=StopMessage(
                                content="An exception occurred in the runtime.", source=self._group_chat_manager_name
                            ),
                            error=SerializableException.from_exception(e),
                        )
                    )

            # 创建一个后台任务，用于在运行时停止时发送停止消息。
            # 停止任务或者运行时异常时，都会发送停止消息。
            self._shutdown_task = asyncio.create_task(stop_runtime())

        while self._is_started :
            await asyncio.sleep(1)
            # 启动工作循环
            # 按顺序收集输出消息。
            # output_messages: List[BaseAgentEvent | BaseChatMessage] = []
            # stop_reason: str | None = None
            # # 迭代输出消息队列，直到队列为空。
            # while True:
            #     message_future = asyncio.ensure_future(self._output_message_queue.get())
            #     # 等待下一个消息，如果任务被取消，将抛出异常。
            #     message = await message_future
            #     if isinstance(message, GroupChatTermination):
            #         # 检查是否有错误，如果有错误，则抛出异常。
            #         # 这将停止团队并传播错误。
            #         if message.error is not None:
            #             raise RuntimeError(str(message.error))
            #         stop_reason = message.message.content
            #         break
            #     yield message
            #     if isinstance(message, ModelClientStreamingChunkEvent):
            #         # 跳过模型客户端流式块事件。
            #         continue
            #     output_messages.append(message)
            #
            # # 迭代返回最终结果包含所有输出消息和停止原因。
            # yield TaskResult(messages=output_messages, stop_reason=stop_reason)

    async def add_member(self, member: ChatAgent) -> None:
        """
        添加成员到团队。
        Args:
            member: 要添加的团队成员
        """
        if self._initialized:
            raise RuntimeError("团队已经初始化,不能添加成员。")

        # 检查member是否已经在团队中
        if member.name in self._participant_names:
            raise ValueError(f"成员 {member.name} 已经在团队中。")


        # 添加成员到团队
        self._participants.append(member)
        self._participant_names.append(member.name)
        new_agent_type = f"{member.name}_{self._team_id}"
        self._participant_topic_types.append(new_agent_type)

    async def remove_member(self, member_name: str) -> None:
        """
        从团队中删除成员。

        Args:
            member_name: 要删除的成员ID
        """
        if self._initialized:
            raise RuntimeError("团队已经初始化,不能添加成员。")
        new_agent_type = f"{member_name}_{self._team_id}"
        # 删除成员
        if member_name in self._participant_names:
            self._participants=[member for member in self._participants if member.name != member_name]
            self._participant_names.remove(member_name)
            self._participant_topic_types.remove(new_agent_type)

    async def stop(self) -> None:
        """
        停止团队运行。
        """
        if not self._initialized:
            raise RuntimeError("团队未初始化。只有运行中的团队才能停止。")
        if not self._is_running:
            raise RuntimeError("团队未运行。")

        try:
            if self._shutdown_task is not None:
                # Wait for the shutdown task to finish.
                # This will propagate any exceptions raised.
                await self._shutdown_task
        finally:
            # Clear the output message queue.
            while not self._output_message_queue.empty():
                self._output_message_queue.get_nowait()

            # Indicate that the team is no longer running.
            self._is_running = False